home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / libpng / pngtrans.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-15  |  17.3 KB  |  566 lines
  1.  
  2. /* pngtrans.c - transforms the data in a row (used by both readers and writers)
  3.  
  4.    libpng 1.0 beta 6 - version 0.96
  5.    For conditions of distribution and use, see copyright notice in png.h
  6.    Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  7.    Copyright (c) 1996, 1997 Andreas Dilger
  8.    May 12, 1997
  9.    */
  10.  
  11. #define PNG_INTERNAL
  12. #include "png.h"
  13.  
  14. #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
  15. /* turn on bgr to rgb mapping */
  16. void
  17. png_set_bgr(png_structp png_ptr)
  18. {
  19.    png_debug(1, "in png_set_bgr\n");
  20.    png_ptr->transformations |= PNG_BGR;
  21. }
  22. #endif
  23.  
  24. #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
  25. /* turn on 16 bit byte swapping */
  26. void
  27. png_set_swap(png_structp png_ptr)
  28. {
  29.    png_debug(1, "in png_set_swap\n");
  30.    if (png_ptr->bit_depth == 16)
  31.       png_ptr->transformations |= PNG_SWAP_BYTES;
  32. }
  33. #endif
  34.  
  35. #if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
  36. /* turn on pixel packing */
  37. void
  38. png_set_packing(png_structp png_ptr)
  39. {
  40.    png_debug(1, "in png_set_packing\n");
  41.    if (png_ptr->bit_depth < 8)
  42.    {
  43.       png_ptr->transformations |= PNG_PACK;
  44.       png_ptr->usr_bit_depth = 8;
  45.    }
  46. }
  47. #endif
  48.  
  49. #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
  50. /* turn on packed pixel swapping */
  51. void
  52. png_set_packswap(png_structp png_ptr)
  53. {
  54.    png_debug(1, "in png_set_packswap\n");
  55.    if (png_ptr->bit_depth < 8)
  56.       png_ptr->transformations |= PNG_PACKSWAP;
  57. }
  58. #endif
  59.  
  60. #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
  61. void
  62. png_set_shift(png_structp png_ptr, png_color_8p true_bits)
  63. {
  64.    png_debug(1, "in png_set_shift\n");
  65.    png_ptr->transformations |= PNG_SHIFT;
  66.    png_ptr->shift = *true_bits;
  67. }
  68. #endif
  69.  
  70. #if defined(PNG_READ_INTERLACING_SUPPORTED) || defined(PNG_WRITE_INTERLACING_SUPPORTED)
  71. int
  72. png_set_interlace_handling(png_structp png_ptr)
  73. {
  74.    png_debug(1, "in png_set_interlace handling\n");
  75.    if (png_ptr->interlaced)
  76.    {
  77.       png_ptr->transformations |= PNG_INTERLACE;
  78.       return 7;
  79.    }
  80.  
  81.    return 1;
  82. }
  83. #endif
  84.  
  85. #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
  86. /* Add a filler byte on read, or remove a filler or alpha byte on write.
  87.  * The filler type has changed in v0.95 to allow future 2-byte fillers
  88.  * for 48-bit input data, as well as avoiding problems with some compilers
  89.  * which don't like bytes as parameters.
  90.  */
  91. void
  92. png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
  93. {
  94.    png_debug(1, "in png_set_filler\n");
  95.    png_ptr->transformations |= PNG_FILLER;
  96.    png_ptr->filler = (png_byte)filler;
  97.    if (filler_loc == PNG_FILLER_AFTER)
  98.       png_ptr->flags |= PNG_FLAG_FILLER_AFTER;
  99.    else
  100.       png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;
  101.  
  102.    /* This should probably go in the "do_filler" routine */
  103.    if (png_ptr->color_type == PNG_COLOR_TYPE_RGB && png_ptr->bit_depth == 8)
  104.    {
  105.       png_ptr->usr_channels = 4;
  106.    }
  107. }
  108. #endif
  109.  
  110. #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
  111.     defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
  112. void
  113. png_set_swap_alpha(png_structp png_ptr)
  114. {
  115.    png_debug(1, "in png_set_swap_alpha\n");
  116.    png_ptr->transformations |= PNG_SWAP_ALPHA;
  117. }
  118. #endif
  119.  
  120. #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
  121. void
  122. png_set_invert_mono(png_structp png_ptr)
  123. {
  124.    png_debug(1, "in png_set_invert_mono\n");
  125.    png_ptr->transformations |= PNG_INVERT_MONO;
  126. }
  127.  
  128. /* invert monocrome grayscale data */
  129. void
  130. png_do_invert(png_row_infop row_info, png_bytep row)
  131. {
  132.    png_debug(1, "in png_do_invert\n");
  133.    if (row_info->bit_depth == 1 &&
  134. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  135.        row != NULL && row_info != NULL &&
  136. #endif
  137.        row_info->color_type == PNG_COLOR_TYPE_GRAY)
  138.    {
  139.       png_bytep rp;
  140.       png_uint_32 i;
  141.  
  142.       for (i = 0, rp = row; i < row_info->rowbytes; i++, rp++)
  143.       {
  144.          *rp = (png_byte)(~(*rp));
  145.       }
  146.    }
  147. }
  148. #endif
  149.  
  150. #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
  151. /* swaps byte order on 16 bit depth images */
  152. void
  153. png_do_swap(png_row_infop row_info, png_bytep row)
  154. {
  155.    png_debug(1, "in png_do_swap\n");
  156.    if (
  157. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  158.        row != NULL && row_info != NULL &&
  159. #endif
  160.        row_info->bit_depth == 16)
  161.    {
  162.       png_bytep rp;
  163.       png_byte t;
  164.       png_uint_32 i;
  165.  
  166.       for (i = 0, rp = row;
  167.          i < row_info->width * row_info->channels;
  168.          i++, rp += 2)
  169.       {
  170.          t = *rp;
  171.          *rp = *(rp + 1);
  172.          *(rp + 1) = t;
  173.       }
  174.    }
  175. }
  176. #endif
  177.  
  178. #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
  179. static png_byte onebppswaptable[256] = {
  180.    0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
  181.    0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
  182.    0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
  183.    0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
  184.    0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
  185.    0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
  186.    0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
  187.    0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
  188.    0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
  189.    0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
  190.    0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
  191.    0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
  192.    0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
  193.    0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
  194.    0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
  195.    0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
  196.    0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
  197.    0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
  198.    0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
  199.    0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
  200.    0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
  201.    0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
  202.    0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
  203.    0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
  204.    0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
  205.    0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
  206.    0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
  207.    0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
  208.    0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
  209.    0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
  210.    0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
  211.    0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
  212. };
  213.  
  214. static png_byte twobppswaptable[256] = {
  215.    0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,
  216.    0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,
  217.    0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,
  218.    0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,
  219.    0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,
  220.    0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,
  221.    0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,
  222.    0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,
  223.    0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,
  224.    0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,
  225.    0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,
  226.    0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,
  227.    0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,
  228.    0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,
  229.    0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,
  230.    0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,
  231.    0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,
  232.    0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,
  233.    0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,
  234.    0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,
  235.    0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,
  236.    0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,
  237.    0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,
  238.    0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,
  239.    0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,
  240.    0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,
  241.    0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,
  242.    0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,
  243.    0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,
  244.    0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,
  245.    0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,
  246.    0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF
  247. };
  248.  
  249. static png_byte fourbppswaptable[256] = {
  250.    0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
  251.    0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,
  252.    0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
  253.    0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,
  254.    0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,
  255.    0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,
  256.    0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,
  257.    0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,
  258.    0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,
  259.    0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,
  260.    0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,
  261.    0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,
  262.    0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,
  263.    0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,
  264.    0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,
  265.    0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,
  266.    0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,
  267.    0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,
  268.    0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,
  269.    0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,
  270.    0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,
  271.    0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,
  272.    0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,
  273.    0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,
  274.    0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,
  275.    0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,
  276.    0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,
  277.    0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,
  278.    0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,
  279.    0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,
  280.    0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,
  281.    0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF
  282. };
  283.  
  284. /* swaps pixel packing order within bytes */
  285. void
  286. png_do_packswap(png_row_infop row_info, png_bytep row)
  287. {
  288.    png_debug(1, "in png_do_packswap\n");
  289.    if (
  290. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  291.        row != NULL && row_info != NULL
  292. #endif
  293.        row_info->bit_depth < 8)
  294.    {
  295.       png_bytep rp, end, table;
  296.  
  297.       end = row + row_info->rowbytes;
  298.  
  299.       if (row_info->bit_depth == 1)
  300.          table = onebppswaptable;
  301.       else if (row_info->bit_depth == 2)
  302.          table = twobppswaptable;
  303.       else if (row_info->bit_depth == 4)
  304.          table = fourbppswaptable;
  305.       else
  306.          return;
  307.  
  308.       for (rp = row; rp < end; rp++)
  309.          *rp = table[*rp];
  310.    }
  311. }
  312. #endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */
  313.  
  314. #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
  315.     defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
  316. /* remove filler or alpha byte(s) */
  317. void
  318. png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
  319. {
  320.    png_debug(1, "in png_do_strip_filler\n");
  321. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  322.    if (row != NULL && row_info != NULL)
  323. #endif
  324.    {
  325. /*
  326.       if (row_info->color_type == PNG_COLOR_TYPE_RGB ||
  327.           row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
  328. */
  329.       if (row_info->channels == 4)
  330.       {
  331.          if (row_info->bit_depth == 8)
  332.          {
  333.             /* This converts from RGBX or RGBA to RGB */
  334.             if (flags & PNG_FLAG_FILLER_AFTER)
  335.             {
  336.                png_bytep sp, dp;
  337.                png_uint_32 i;
  338.  
  339.                for (i = 1, sp = row + 4, dp = row + 3; i < row_info->width; i++)
  340.                {
  341.                   *dp++ = *sp++;
  342.                   *dp++ = *sp++;
  343.                   *dp++ = *sp++;
  344.                   sp++;
  345.                }
  346.             }
  347.             /* This converts from XRGB or ARGB to RGB */
  348.             else
  349.             {
  350.                png_bytep sp, dp;
  351.                png_uint_32 i;
  352.  
  353.                for (i = 0, sp = row, dp = row; i < row_info->width; i++)
  354.                {
  355.                   sp++;
  356.                   *dp++ = *sp++;
  357.                   *dp++ = *sp++;
  358.                   *dp++ = *sp++;
  359.                }
  360.             }
  361.             row_info->pixel_depth = 24;
  362.             row_info->rowbytes = row_info->width * 3;
  363.          }
  364.          else /* if (row_info->bit_depth == 16) */
  365.          {
  366.             if (flags & PNG_FLAG_FILLER_AFTER)
  367.             {
  368.                png_bytep sp, dp;
  369.                png_uint_32 i;
  370.  
  371.                /* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */
  372.                for (i = 1, sp = row + 8, dp = row + 6; i < row_info->width; i++)
  373.                {
  374.                   /* This could be (although memcpy is probably slower):
  375.                   png_memcpy(dp, sp, 6);
  376.                   sp += 8;
  377.                   dp += 6;
  378.                   */
  379.                   *dp++ = *sp++;
  380.                   *dp++ = *sp++;
  381.                   *dp++ = *sp++;
  382.                   *dp++ = *sp++;
  383.                   *dp++ = *sp++;
  384.                   *dp++ = *sp++;
  385.                   sp += 2;
  386.                }
  387.             }
  388.             else
  389.             {
  390.                png_bytep sp, dp;
  391.                png_uint_32 i;
  392.  
  393.                /* This converts from XXRRGGBB or AARRGGBB to RRGGBB */
  394.                for (i = 0, sp = row + 2, dp = row; i < row_info->width; i++)
  395.                {
  396.                   /* This could be (although memcpy is probably slower):
  397.                   png_memcpy(dp, sp, 6);
  398.                   sp += 8;
  399.                   dp += 6;
  400.                   */
  401.                   *dp++ = *sp++;
  402.                   *dp++ = *sp++;
  403.                   *dp++ = *sp++;
  404.                   *dp++ = *sp++;
  405.                   *dp++ = *sp++;
  406.                   *dp++ = *sp++;
  407.                }
  408.             }
  409.             row_info->pixel_depth = 48;
  410.             row_info->rowbytes = row_info->width * 6;
  411.          }
  412.          row_info->channels = 3;
  413.       }
  414. /*
  415.       else if (row_info->color_type == PNG_COLOR_TYPE_GRAY ||
  416.                row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
  417. */
  418.       else if (row_info->channels == 2)
  419.       {
  420.          if (row_info->bit_depth == 8)
  421.          {
  422.             /* This converts from GX or GA to G */
  423.             if (flags & PNG_FLAG_FILLER_AFTER)
  424.             {
  425.                png_bytep sp, dp;
  426.                png_uint_32 i;
  427.  
  428.                for (i = 1, sp = row + 2, dp = row + 1; i < row_info->width; i++)
  429.                {
  430.                   *dp++ = *sp++;
  431.                   sp++;
  432.                }
  433.             }
  434.             /* This converts from XG or AG to G */
  435.             else
  436.             {
  437.                png_bytep sp, dp;
  438.                png_uint_32 i;
  439.  
  440.                for (i = 0, sp = row, dp = row; i < row_info->width; i++)
  441.                {
  442.                   sp++;
  443.                   *dp++ = *sp++;
  444.                }
  445.             }
  446.             row_info->pixel_depth = 8;
  447.             row_info->rowbytes = row_info->width;
  448.          }
  449.          else /* if (row_info->bit_depth == 16) */
  450.          {
  451.             if (flags & PNG_FLAG_FILLER_AFTER)
  452.             {
  453.                png_bytep sp, dp;
  454.                png_uint_32 i;
  455.  
  456.                /* This converts from GGXX or GGAA to GG */
  457.                for (i = 1, sp = row + 4, dp = row + 2; i < row_info->width; i++)
  458.                {
  459.                   *dp++ = *sp++;
  460.                   *dp++ = *sp++;
  461.                   sp += 2;
  462.                }
  463.             }
  464.             else
  465.             {
  466.                png_bytep sp, dp;
  467.                png_uint_32 i;
  468.  
  469.                /* This converts from XXGG or AAGG to GG */
  470.                for (i = 0, sp = row, dp = row; i < row_info->width; i++)
  471.                {
  472.                   sp += 2;
  473.                   *dp++ = *sp++;
  474.                   *dp++ = *sp++;
  475.                }
  476.             }
  477.             row_info->pixel_depth = 16;
  478.             row_info->rowbytes = row_info->width * 2;
  479.          }
  480.          row_info->channels = 1;
  481.       }
  482.    }
  483. }
  484. #endif
  485.  
  486. #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
  487. /* swaps red and blue bytes within a pixel */
  488. void
  489. png_do_bgr(png_row_infop row_info, png_bytep row)
  490. {
  491.    png_debug(1, "in png_do_bgr\n");
  492.    if (
  493. #if defined(PNG_USELESS_TESTS_SUPPORTED)
  494.        row != NULL && row_info != NULL &&
  495. #endif
  496.        (row_info->color_type & PNG_COLOR_MASK_COLOR))
  497.    {
  498.       if (row_info->bit_depth == 8)
  499.       {
  500.          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
  501.          {
  502.             png_bytep rp;
  503.             png_byte save;
  504.             png_uint_32 i;
  505.  
  506.             for (i = 0, rp = row; i < row_info->width; i++, rp += 3)
  507.             {
  508.                save = *rp;
  509.                *rp = *(rp + 2);
  510.                *(rp + 2) = save;
  511.             }
  512.          }
  513.          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
  514.          {
  515.             png_bytep rp;
  516.             png_byte save;
  517.             png_uint_32 i;
  518.  
  519.             for (i = 0, rp = row; i < row_info->width; i++, rp += 4)
  520.             {
  521.                save = *rp;
  522.                *rp = *(rp + 2);
  523.                *(rp + 2) = save;
  524.             }
  525.          }
  526.       }
  527.       else if (row_info->bit_depth == 16)
  528.       {
  529.          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
  530.          {
  531.             png_bytep rp;
  532.             png_byte save[2];
  533.             png_uint_32 i;
  534.  
  535.             for (i = 0, rp = row; i < row_info->width; i++, rp += 6)
  536.             {
  537.                save[0] = *rp;
  538.                save[1] = *(rp + 1);
  539.                *rp = *(rp + 4);
  540.                *(rp + 1) = *(rp + 5);
  541.                *(rp + 4) = save[0];
  542.                *(rp + 5) = save[1];
  543.             }
  544.          }
  545.          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
  546.          {
  547.             png_bytep rp;
  548.             png_byte save[2];
  549.             png_uint_32 i;
  550.  
  551.             for (i = 0, rp = row; i < row_info->width; i++, rp += 8)
  552.             {
  553.                save[0] = *rp;
  554.                save[1] = *(rp + 1);
  555.                *rp = *(rp + 4);
  556.                *(rp + 1) = *(rp + 5);
  557.                *(rp + 4) = save[0];
  558.                *(rp + 5) = save[1];
  559.             }
  560.          }
  561.       }
  562.    }
  563. }
  564. #endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */
  565.  
  566.